#!/bin/bash
# 颜色定义
COLOR_INFO='\033[34m'    # 蓝色信息
COLOR_SUCCESS='\033[32m' # 绿色成功
COLOR_ERROR='\033[31m'   # 红色错误
COLOR_WARNING='\033[33m' # 黄色警告
COLOR_RESET='\033[0m'    # 重置颜色
INSTALL_MODE_FILE="/etc/euler_Intelligence_install_mode"
# 全局模式标记
OFFLINE_MODE=false

# 检查系统版本并返回兼容的 el 版本
get_el_version() {
  # 首先检查是否为 openEuler 系统
  if [ -f "/etc/openEuler-release" ]; then
    local openeuler_version
    openeuler_version=$(grep -Eo 'openEuler release [0-9]+\.[0-9]+' /etc/openEuler-release | awk '{print $3}' | tail -n 1)

    if [ -n "$openeuler_version" ]; then
      # 将版本号转换为可比较的数字格式（如 22.03 -> 2203）
      local major minor
      major=$(echo "$openeuler_version" | cut -d'.' -f1)
      minor=$(echo "$openeuler_version" | cut -d'.' -f2)

      if [[ "$major" =~ ^[0-9]+$ && "$minor" =~ ^[0-9]+$ ]]; then
        local version_num=$((10#$major * 100 + 10#$minor))

        # openEuler 22.03 及之前使用 el8，24.03 及之后使用 el9
        if [ $version_num -le 2203 ]; then
          echo "8"
          return 0
        else
          echo "9"
          return 0
        fi
      fi
    fi
  fi

  # 如果不是标准的 openEuler 或无法获取版本，则检查内核版本
  echo -e "${COLOR_WARNING}[Warning] 非标准 openEuler 系统，基于内核版本判断 el 版本${COLOR_RESET}" >&2
  local kernel_version
  kernel_version=$(uname -r | cut -d'.' -f1,2)

  # 将版本号转换为可比较的数字格式
  local major minor
  major=$(echo "$kernel_version" | cut -d'.' -f1)
  minor=$(echo "$kernel_version" | cut -d'.' -f2)

  if [[ "$major" =~ ^[0-9]+$ && "$minor" =~ ^[0-9]+$ ]]; then
    local version_num=$((10#$major * 100 + 10#$minor))

    # 内核版本 < 5.14 使用 el8，>= 5.14 使用 el9
    if [ $version_num -lt 514 ]; then
      echo "8"
      return 0
    else
      echo "9"
      return 0
    fi
  fi

  echo -e "${COLOR_ERROR}[Error] 无法确定兼容的 el 版本，请检查系统信息${COLOR_RESET}" >&2
  return 1
}

# 安装wget工具
install_wget() {
  echo -e "${COLOR_INFO}[INFO] 正在尝试安装wget...${COLOR_RESET}"

  # 检查包管理器并安装
  if command -v apt-get &>/dev/null; then
    sudo apt-get update && sudo apt-get install -y wget
  elif command -v yum &>/dev/null; then
    sudo yum install -y wget
  elif command -v dnf &>/dev/null; then
    sudo dnf install -y wget
  elif command -v zypper &>/dev/null; then
    sudo zypper install -y wget
  else
    echo -e "${COLOR_FAILURE}[ERROR] 无法确定包管理器，请手动安装wget${COLOR_RESET}"
    return 1
  fi

  # 验证安装是否成功
  if command -v wget &>/dev/null; then
    echo -e "${COLOR_SUCCESS}[SUCCESS] wget安装成功${COLOR_RESET}"
    return 0
  else
    echo -e "${COLOR_FAILURE}[ERROR] wget安装失败${COLOR_RESET}"
    return 1
  fi
}

# 基础URL列表（无论RAG是否启用都需要检测）
get_mongodb_urls() {
  local el_version arch
  el_version=$(get_el_version)
  arch=$(uname -m)

  # 根据架构映射到对应的包架构名称
  case "$arch" in
  x86_64 | i386 | i686)
    local pkg_arch="x86_64"
    ;;
  aarch64 | arm64)
    local pkg_arch="aarch64"
    ;;
  *)
    echo -e "${COLOR_ERROR}[Error] 不支持的架构: $arch${COLOR_RESET}"
    echo -e "${COLOR_ERROR}[Error] 仅支持 x86_64、aarch64 架构${COLOR_RESET}"
    return 1
    ;;
  esac

  # 检查本地MongoDB缓存文件是否存在
  local mongodb_dir="/opt/mongodb"
  local mongodb_server="$mongodb_dir/mongodb-org-server-7.0.21-1.el${el_version}.${pkg_arch}.rpm"
  local mongodb_mongosh="$mongodb_dir/mongodb-mongosh-2.5.2.${pkg_arch}.rpm"

  # 如果所有MongoDB文件都已缓存，则跳过网络检查
  if [ -f "$mongodb_server" ] && [ -f "$mongodb_mongosh" ]; then
    echo -e "${COLOR_INFO}[Info] MongoDB RPM文件已缓存，跳过网络连接检查${COLOR_RESET}"
    base_urls=() # 清空URL列表
    return 0
  fi

  # 如果缓存不完整，添加需要下载的URL到检查列表
  base_urls=()
  if [ ! -f "$mongodb_server" ]; then
    base_urls+=("https://repo.mongodb.org/yum/redhat/${el_version}/mongodb-org/7.0/${pkg_arch}/RPMS/mongodb-org-server-7.0.21-1.el${el_version}.${pkg_arch}.rpm")
  fi
  if [ ! -f "$mongodb_mongosh" ]; then
    base_urls+=("https://downloads.mongodb.com/compass/mongodb-mongosh-2.5.2.${pkg_arch}.rpm")
  fi

  if [ ${#base_urls[@]} -gt 0 ]; then
    echo -e "${COLOR_INFO}[Info] 需要检查 ${#base_urls[@]} 个MongoDB相关URL的网络连接${COLOR_RESET}"
  fi
}

# RAG专用URL列表（仅当RAG启用时检测）
rag_urls=(
  "https://bgithub.xyz/pgvector/pgvector.git"
  "https://bgithub.xyz/amutu/zhparser.git"
)

# 检测URL可达性的函数
check_url_accessibility() {
  # 首先检查wget是否安装
  if ! command -v wget &>/dev/null; then
    echo -e "${COLOR_WARNING}[WARN] wget未安装，尝试自动安装...${COLOR_RESET}"
    if ! install_wget; then
      echo -e "${COLOR_ERROR}[ERROR] URL检测中止：wget安装失败${COLOR_RESET}"
      return 1
    fi
  fi

  # 读取RAG安装状态（依赖之前的read_install_mode函数设置RAG_INSTALL变量）
  if ! read_install_mode; then
    echo -e "${COLOR_WARNING}[WARN] 无法读取安装模式，默认按RAG未启用检测${COLOR_RESET}"
    local RAG_INSTALL="n"
  fi

  # 根据架构和RAG状态组合最终需要检测的URL列表
  local detect_urls=()

  # 初始化 MongoDB URLs
  get_mongodb_urls
  detect_urls+=("${base_urls[@]}")

  # 如果启用RAG，添加RAG专用URL
  if [ "$RAG_INSTALL" = "y" ]; then
    detect_urls+=("${rag_urls[@]}")
    echo -e "${COLOR_INFO} RAG组件已启用，将检测所有必要URL（共${#detect_urls[@]}个）${COLOR_RESET}"
  else
    echo -e "${COLOR_INFO} RAG组件未启用，仅检测基础URL（共${#detect_urls[@]}个）${COLOR_RESET}"
  fi

  local all_success=true
  local timeout_seconds=15 # 设置超时时间
  local failed_urls=()     # 存储失败的URL
  local temp_file          # 创建临时文件
  temp_file=$(mktemp)

  echo -e "${COLOR_INFO}开始检测URL可达性...${COLOR_RESET}"
  echo -e "${COLOR_INFO}超时时间: ${timeout_seconds}秒${COLOR_RESET}"

  for url in "${detect_urls[@]}"; do
    # 格式化输出，保持对齐
    printf "%-80s" "检测: $url"

    # 使用timeout命令控制超时，--spider只检查URL是否存在不下载
    if timeout $timeout_seconds wget --spider --timeout=$timeout_seconds --tries=1 --no-check-certificate "$url" >"$temp_file" 2>&1; then
      echo -e "${COLOR_SUCCESS} [OK]${COLOR_RESET}"
    else
      echo -e "${COLOR_ERROR} [FAIL]${COLOR_RESET}"

      # 提取错误原因
      if grep -q "timed out" "$temp_file"; then
        error_msg="操作超时 (${timeout_seconds}秒)"
      else
        error_msg=$(grep -i "error\|failed\|timeout" "$temp_file" | head -1 | cut -d' ' -f4- | sed 's/[[:cntrl:]]//g')
      fi

      echo -e "  ${COLOR_WARNING}原因: ${error_msg:-未知错误}${COLOR_RESET}"
      all_success=false
      failed_urls+=("$url")
    fi
  done

  # 清理临时文件
  rm -rf "$temp_file"

  # 结果汇总
  echo -e "\n${COLOR_INFO}====== 检测结果 ======${COLOR_RESET}"
  if $all_success; then
    echo -e "${COLOR_SUCCESS}[Success] 所有必要URL均可访问${COLOR_RESET}"
    return 0
  else
    echo -e "${COLOR_ERROR}[Error] ${#failed_urls[@]}个URL不可访问:${COLOR_RESET}"
    printf "  - %s\n" "${failed_urls[@]}"
    echo -e "${COLOR_INFO}建议检查:${COLOR_RESET}"
    echo -e "  1. 网络连接是否正常"
    echo -e "  2. 是否需要配置代理(export http_proxy=...)"
    return 1
  fi
}

# 全局变量：默认端口列表（未启用Web时）
PORTS=(8002)

# 读取安装模式并设置端口列表的函数
init_ports_based_on_web() {
  if ! read_install_mode; then
    echo -e "${COLOR_WARNING}[Warning] 无法读取安装模式，使用默认端口配置${COLOR_RESET}"
    return 1
  fi

  # 根据Web组件状态更新全局PORTS变量
  if [ "$WEB_INSTALL" = "y" ]; then
    PORTS=(8080 9888 8000 11120)
    echo -e "${COLOR_INFO} Web组件已启用，端口列表: ${PORTS[*]}${COLOR_RESET}"
  else
    PORTS=(8002)
    echo -e "${COLOR_INFO} Web组件未启用，端口列表: ${PORTS[*]}${COLOR_RESET}"
  fi
}

function check_user {
  if [[ $(id -u) -ne 0 ]]; then
    echo -e "${COLOR_ERROR}[Error] 请以root权限运行该脚本！${COLOR_RESET}"
    return 1
  fi
  return 0
}

function check_version {
  local current_version_id="$1"
  local sp="$2"
  local supported_versions=("${@:3}")
  echo -e "${COLOR_INFO}[Info] 当前操作系统版本为：$current_version_id LTS-$sp${COLOR_RESET}"
  for version_id in "${supported_versions[@]}"; do
    if [[ "$current_version_id" == "$version_id" ]]; then
      case "$current_version_id" in
      "22.03")
        if [[ "$sp" == "SP4" ]]; then
          echo -e "${COLOR_SUCCESS}[Success] 操作系统满足兼容性要求${COLOR_RESET}"
          return 0
        fi
        ;;
      "24.03")
        if [[ "$sp" == "SP2" || "$sp" == "SP3" ]]; then
          echo -e "${COLOR_SUCCESS}[Success] 操作系统满足兼容性要求${COLOR_RESET}"
          return 0
        fi
        ;;
      "25.03" | "25.09")
        if [[ -z "$sp" ]]; then
          echo -e "${COLOR_SUCCESS}[Success] 操作系统满足兼容性要求${COLOR_RESET}"
          return 0
        fi
        ;;
      esac
    fi
  done

  echo -e "${COLOR_ERROR}[Error] 操作系统不满足兼容性要求，脚本将退出${COLOR_RESET}"
  return 1
}

function check_os_version {
  local id
  local version
  local sp
  id=$(grep '^ID=' /etc/os-release | cut -d= -f2 | tr -d '"')
  version=$(grep -E "^VERSION_ID=" /etc/os-release | cut -d '"' -f 2)
  sp=$(grep -E "^VERSION=" /etc/os-release | grep -oP 'SP\d+')

  echo -e "${COLOR_INFO}[Info] 当前发行版为：$id${COLOR_RESET}"

  case $id in
  "openEuler")
    local supported_versions=("22.03" "24.03" "25.03" "25.09")
    check_version "$version" "$sp" "${supported_versions[@]}"
    ;;
  "hce")
    echo -e "${COLOR_INFO}[Info] 检测到 HCE 发行版，跳过版本检查${COLOR_RESET}"
    return 0
    ;;
  *)
    echo -e "${COLOR_ERROR}[Error] 发行版不受支持，脚本将退出${COLOR_RESET}"
    return 1
    ;;
  esac
  return $?
}

function check_hostname {
  local current_hostname
  current_hostname=$(cat /etc/hostname)
  if [[ -z "$current_hostname" ]]; then
    echo -e "${COLOR_WARNING}[Warning] 未设置主机名，自动设置为localhost${COLOR_RESET}"
    set_hostname "localhost"
    return $?
  else
    echo -e "${COLOR_INFO}[Info] 当前主机名为：$current_hostname${COLOR_RESET}"
    echo -e "${COLOR_SUCCESS}[Success] 主机名已设置${COLOR_RESET}"
    return 0
  fi
}

function set_hostname {
  if ! command -v hostnamectl &>/dev/null; then
    echo -e "$1" >/etc/hostname
    echo -e "${COLOR_SUCCESS}[Success] 手动设置主机名成功${COLOR_RESET}"
    return 0
  fi

  if hostnamectl set-hostname "$1"; then
    echo -e "${COLOR_SUCCESS}[Success] 主机名设置成功${COLOR_RESET}"
    return 0
  else
    echo -e "${COLOR_ERROR}[Error] 主机名设置失败${COLOR_RESET}"
    return 1
  fi
}

# 检查单个软件包是否可用
# 参数: 包名 [备用包名1] [备用包名2] ...
check_package() {
  local primary_pkg=$1
  shift
  local alternate_pkgs=("$@")

  # 先检查主包名
  if dnf list "$primary_pkg" &>/dev/null; then
    echo -e "${COLOR_INFO}[Info] $(printf '%-30s' "$primary_pkg") \t(可用)${COLOR_RESET}"
    return 0
  fi

  # 如果主包名不可用，尝试备用包名
  for alt_pkg in "${alternate_pkgs[@]}"; do
    if dnf list "$alt_pkg" &>/dev/null; then
      echo -e "${COLOR_INFO}[Info] $(printf '%-30s' "$primary_pkg") \t(可用，使用 $alt_pkg)${COLOR_RESET}"
      return 0
    fi
  done

  # 所有包名都不可用
  if [ ${#alternate_pkgs[@]} -gt 0 ]; then
    echo -e "${COLOR_ERROR}[Error] $(printf '%-30s' "$primary_pkg") \t(不可用，已尝试: ${alternate_pkgs[*]})${COLOR_RESET}"
  else
    echo -e "${COLOR_ERROR}[Error] $(printf '%-30s' "$primary_pkg") \t(不可用)${COLOR_RESET}"
  fi
  return 1
}

all_available=true
# 检查所有软件包
# 包名格式: "package_name" 或 "package_name:alternate1:alternate2"
check_packages() {
  local packages=("$@")

  local timeout_seconds=30
  local start_time
  start_time=$(date +%s)

  echo -e "${COLOR_INFO}--------------------------------${COLOR_RESET}"

  for pkg_spec in "${packages[@]}"; do
    # 检查是否超时
    local current_time
    current_time=$(date +%s)
    local elapsed=$((current_time - start_time))

    if [ $elapsed -ge $timeout_seconds ]; then
      echo -e "${COLOR_ERROR}[Error] 检查操作已超时(${timeout_seconds}s)${COLOR_RESET}"
      echo -e "${COLOR_INFO}--------------------------------${COLOR_RESET}"
      return 2
    fi

    # 分割包名和备用名（使用冒号分隔）
    IFS=':' read -ra pkg_names <<<"$pkg_spec"
    if ! check_package "${pkg_names[@]}"; then
      all_available=false
    fi
    sleep 0.1 # 避免请求过快
  done
}
check_web_pkg() {
  local pkgs=(
    "nginx"
    "redis:redis6" # 支持 redis 或 redis6 包名
    "mysql"
    "mysql-server"
    "authHub"
    "authhub-web"
    "euler-copilot-web"
    "euler-copilot-witchaind-web"
  )
  if ! check_packages "${pkgs[@]}"; then
    return 1
  fi
}
check_framework_pkg() {
  local pkgs=(
    "euler-copilot-framework"
    "git"
    "make"
    "gcc"
    "gcc-c++"
    "tar"
    "python3-pip"
  )
  if ! check_packages "${pkgs[@]}"; then
    return 1
  fi
}
check_rag_pkg() {
  local pkgs=(
    "euler-copilot-rag"
    "clang"
    "llvm"
    "java-17-openjdk"
    "postgresql"
    "postgresql-server"
    "postgresql-server-devel"
    "libpq-devel"
  )
  if ! check_packages "${pkgs[@]}"; then
    return 1
  fi
}

function check_network {
  echo -e "${COLOR_INFO}[Info] 检查网络连接...${COLOR_RESET}"

  # 使用TCP检查代替curl
  if timeout 5 bash -c 'cat < /dev/null > /dev/tcp/www.baidu.com/80' 2>/dev/null; then
    echo -e "${COLOR_SUCCESS}[Success] 网络连接正常${COLOR_RESET}"
    return 0
  else
    echo -e "${COLOR_ERROR}[Error] 无法访问外部网络，请检查网络环境 ${COLOR_RESET}"
    return 1
  fi
}

function check_dns {
  echo -e "${COLOR_INFO}[Info] 检查DNS设置${COLOR_RESET}"
  if grep -q "^nameserver" /etc/resolv.conf; then
    echo -e "${COLOR_SUCCESS}[Success] DNS已配置${COLOR_RESET}"
    return 0
  fi

  if $OFFLINE_MODE; then
    echo -e "${COLOR_WARNING}[Warning] 离线模式：请手动配置内部DNS服务器${COLOR_RESET}"
    return 0
  else
    echo -e "${COLOR_WARNING}[Warning] DNS未配置，建议手动设置DNS服务器（如8.8.8.8）${COLOR_RESET}"
    echo -e "${COLOR_INFO}[Info] 可通过以下命令设置：echo 'nameserver 8.8.8.8' >> /etc/resolv.conf${COLOR_RESET}"
    return 0
  fi
}

function check_ram {
  local RAM_THRESHOLD=1024
  local current_mem
  current_mem=$(free -m | awk '/Mem/{print $2}')

  echo -e "${COLOR_INFO}[Info] 当前内存：$current_mem MB${COLOR_RESET}"
  if ((current_mem < RAM_THRESHOLD)); then
    echo -e "${COLOR_ERROR}[Error] 内存不足 ${RAM_THRESHOLD} MB${COLOR_RESET}"
    return 1
  fi
  echo -e "${COLOR_SUCCESS}[Success] 内存满足要求${COLOR_RESET}"
  return 0
}

check_disk_space() {
  local DIR="$1"
  local THRESHOLD="$2"

  local USAGE
  USAGE=$(df --output=pcent "$DIR" | tail -n 1 | sed 's/%//g' | tr -d ' ')

  if [ "$USAGE" -ge "$THRESHOLD" ]; then
    echo -e "${COLOR_WARNING}[Warning] $DIR 的磁盘使用率已达到 ${USAGE}%，超过阈值 ${THRESHOLD}%${COLOR_RESET}"
    return 1
  else
    echo -e "${COLOR_INFO}[Info] $DIR 的磁盘使用率为 ${USAGE}%，低于阈值 ${THRESHOLD}%${COLOR_RESET}"
    return 0
  fi
}

function check_selinux {
  sed -i 's/^SELINUX=.*/SELINUX=disabled/g' /etc/selinux/config
  echo -e "${COLOR_SUCCESS}[Success] SELinux配置已禁用${COLOR_RESET}"
  setenforce 0 &>/dev/null
  echo -e "${COLOR_SUCCESS}[Success] SELinux已临时禁用${COLOR_RESET}"
  return 0
}

function check_firewall {
  systemctl disable --now firewalld &>/dev/null
  echo -e "${COLOR_SUCCESS}[Success] 防火墙已关闭并禁用${COLOR_RESET}"
  return 0
}

# 检查端口是否被占用
check_ports() {
  local occupied=()
  echo -e "${COLOR_INFO}正在检查端口占用情况...${COLOR_RESET}"
  init_ports_based_on_web

  for port in "${PORTS[@]}"; do
    if ss -tuln | grep -q ":${port} "; then
      occupied+=("$port")
      echo -e "${COLOR_WARNING}[Warning] 端口 $port 已被占用${COLOR_RESET}"
    else
      echo -e "${COLOR_INFO}[Info] 端口 $port 可用${COLOR_RESET}"
    fi
  done

  if [ ${#occupied[@]} -gt 0 ]; then
    echo -e "${COLOR_ERROR}[Error]错误: 以下端口已被占用: ${occupied[*]}${COLOR_RESET}"
    echo -e "${COLOR_ERROR}[Error]请先释放这些端口再运行脚本${COLOR_RESET}"
    return 1
  fi
  echo -e "${COLOR_SUCCESS}[Success]检查端口占用情况成功，端口未占用${COLOR_RESET}"
  return 0
}

# 配置防火墙
setup_firewall() {

  echo -e "${COLOR_INFO}[Info]配置防火墙...${COLOR_RESET}"

  if ! systemctl is-active --quiet firewalld; then
    echo -e "${COLOR_SUCCESS}[Success]防火墙未运行${COLOR_RESET}"
    return 0
  fi
  echo -e "${COLOR_INFO}[Info]防火墙已运行，开放端口${COLOR_RESET}"
  for port in "${PORTS[@]}"; do
    echo -e "${COLOR_INFO}[Info]开放端口 $port/tcp...${COLOR_RESET}"
    firewall-cmd --permanent --add-port="${port}"/tcp || {
      echo -e "${COLOR_ERROR}[Error]开放端口 $port 失败！${COLOR_RESET}"
      return 1
    }
  done

  echo -e "${COLOR_INFO}[Info]重新加载防火墙规则...${COLOR_RESET}"
  firewall-cmd --reload || {
    echo -e "${COLOR_ERROR}[Error]防火墙规则重载失败！${COLOR_RESET}"
    return 1
  }
  echo -e "${COLOR_SUCCESS}[Success]重新加载防火墙规则成功${COLOR_RESET}"
  return 0
}
# 读取安装模式的方法
read_install_mode() {
  # 检查文件是否存在
  if [ ! -f "$INSTALL_MODE_FILE" ]; then
    echo "web_install=n" >"$INSTALL_MODE_FILE"
    echo "rag_install=n" >>"$INSTALL_MODE_FILE"
  fi

  # 从文件读取配置（格式：key=value）
  local web_install
  local rag_install
  web_install=$(grep "web_install=" "$INSTALL_MODE_FILE" | cut -d'=' -f2)
  rag_install=$(grep "rag_install=" "$INSTALL_MODE_FILE" | cut -d'=' -f2)

  # 验证读取结果
  if [ -z "$web_install" ] || [ -z "$rag_install" ]; then
    echo -e "${COLOR_ERROR}[Error] 安装模式文件格式错误${COLOR_RESET}"
    return 1
  fi
  # 将结果存入全局变量（供其他函数使用）
  WEB_INSTALL=$web_install
  RAG_INSTALL=$rag_install
  return 0
}
# 示例：根据安装模式执行对应操作（可根据实际需求扩展）
install_components() {
  # 读取安装模式
  read_install_mode || return 1
  echo -e "${COLOR_INFO}[Info] 检查软件包是否可用${COLOR_RESET}"
  if [ "$WEB_INSTALL" = "y" ]; then
    check_web_pkg
  fi

  if [ "$RAG_INSTALL" = "y" ]; then
    # 此处添加RAG安装命令，示例：
    check_rag_pkg
  fi

  check_framework_pkg
  echo -e "--------------------------------"

  if $all_available; then
    echo -e "${COLOR_SUCCESS}[Success] 所有软件包都可用${COLOR_RESET}"
    return 0
  else
    echo -e "${COLOR_ERROR}[Error] 部分软件包不可用${COLOR_RESET}"
    echo -e "${COLOR_INFO}[Info] 提示：可以尝试以下命令更新仓库缓存：${COLOR_RESET}"
    echo -e "${COLOR_INFO}[Info] sudo dnf clean all && sudo dnf makecache${COLOR_RESET}"
    return 1
  fi
}

function main {
  check_user || return 1
  check_os_version || return 1
  check_hostname || return 1

  # 网络检查与模式判断
  install_components || return 1

  check_dns || return 1
  check_ram || return 1
  check_disk_space "/" 70

  if [ $? -eq 1 ]; then
    echo -e "${COLOR_WARNING}[Warning] 需要清理磁盘空间！${COLOR_RESET}"
  else
    echo -e "${COLOR_SUCCESS}[Success] 磁盘空间正常${COLOR_RESET}"
  fi

  check_selinux || return 1
  check_ports || return 1
  setup_firewall || return 1
  check_url_accessibility || return 1

  # 最终部署提示
  echo -e "\n${COLOR_SUCCESS}#####################################"
  echo -e "#   环境检查完成，准备在线部署     #"
  echo -e "#####################################${COLOR_RESET}"
  return 0
}

main
